// 传输队列页面脚本

// 获取 ipcRenderer（避免重复声明）
if (typeof ipcRenderer === 'undefined') {
  var { ipcRenderer } = require('electron');
}

// 全局变量
let allTasks = []; // 存储所有任务
let currentFilter = {
  type: 'upload', // 'upload' 或 'download'
  status: 'uploading' // 'uploading' 或 'completed'
};

// 初始化函数
async function initQueue() {
  console.log('[Queue] 传输队列页面初始化开始');
  console.log('[Queue] 当前 DOM 状态:', document.readyState);
  
  // 检查关键元素是否存在
  const sidebar = document.querySelector('.queue-sidebar');
  const contentFrame = document.querySelector('#contentFrame');
  console.log('[Queue] 侧边栏元素:', sidebar ? '存在' : '不存在');
  console.log('[Queue] 内容区元素:', contentFrame ? '存在' : '不存在');
  
  console.log('[Queue] 开始初始化组件');
  
  initQueueMenu();
  initQueueTabs();
  initQueueActions();
  
  // 加载任务数据
  try {
    await loadTransferTasks();
  } catch (error) {
    console.error('[Queue] 加载任务失败:', error);
  }
  
  // 监听任务更新事件（只设置一次）
  if (!window.queueListenersSetup) {
    setupTaskListeners();
    window.queueListenersSetup = true;
  }
  
  console.log('[Queue] 传输队列页面初始化完成');
}

// 将 initQueue 暴露到 window，供 base.js 调用
window.initQueue = initQueue;

// 初始化左侧子菜单
function initQueueMenu() {
  console.log('[Queue] 开始初始化子菜单');
  
  // 使用事件委托，绑定到父元素
  const queueSidebar = document.querySelector('.queue-sidebar');
  
  if (!queueSidebar) {
    console.error('[Queue] 未找到 .queue-sidebar 元素！');
    
    // 打印所有可能的容器
    console.log('[Queue] contentFrame:', document.querySelector('#contentFrame'));
    console.log('[Queue] main-container:', document.querySelector('.main-container'));
    console.log('[Queue] queue-layout:', document.querySelector('.queue-layout'));
    
    return;
  }
  
  console.log('[Queue] 找到侧边栏，使用事件委托');
  
  // 使用事件委托监听点击
  queueSidebar.addEventListener('click', (e) => {
    console.log('[Queue] 侧边栏被点击，target:', e.target);
    
    // 找到被点击的菜单项
    const menuItem = e.target.closest('.queue-menu-item');
    
    if (!menuItem) {
      console.log('[Queue] 点击的不是菜单项');
      return;
    }
    
    const type = menuItem.dataset.type;
    console.log('[Queue] 菜单项被点击:', type);
    
    // 移除所有active类
    const allItems = queueSidebar.querySelectorAll('.queue-menu-item');
    allItems.forEach(m => m.classList.remove('active'));
    
    // 添加active到当前项
    menuItem.classList.add('active');
    
    console.log('[Queue] 切换到:', type === 'upload' ? '上传' : '下载');
    
    // 更新当前过滤器
    currentFilter.type = type;
    
    // 根据类型过滤任务
    filterAndRenderTasks();
  });
  
  // 检查有多少个菜单项
  const menuItems = queueSidebar.querySelectorAll('.queue-menu-item');
  console.log('[Queue] 找到子菜单项:', menuItems.length);
  menuItems.forEach((item, i) => {
    console.log(`[Queue]   菜单项 ${i + 1}: ${item.dataset.type}, 文字: "${item.textContent.trim()}"`);
  });
  
  console.log('[Queue] 子菜单初始化完成（使用事件委托）');
}

// 初始化队列标签页
function initQueueTabs() {
  const tabs = document.querySelectorAll('.queue-tab');
  tabs.forEach(tab => {
    tab.addEventListener('click', () => {
      tabs.forEach(t => t.classList.remove('active'));
      tab.classList.add('active');
      
      const tabType = tab.dataset.tab;
      console.log('[Queue] 切换状态标签:', tabType);
      
      // 更新当前过滤器
      currentFilter.status = tabType;
      
      // 根据标签类型显示/隐藏按钮
      const pauseAllBtn = document.getElementById('pauseAllBtn');
      const cancelAllBtn = document.getElementById('cancelAllBtn');
      
      if (tabType === 'completed') {
        // 已完成标签：隐藏全部暂停和全部取消
        if (pauseAllBtn) pauseAllBtn.style.display = 'none';
        if (cancelAllBtn) cancelAllBtn.style.display = 'none';
      } else {
        // 传输中标签：显示全部暂停和全部取消
        if (pauseAllBtn) pauseAllBtn.style.display = '';
        if (cancelAllBtn) cancelAllBtn.style.display = '';
      }
      
      // 重新过滤并渲染
      filterAndRenderTasks();
    });
  });
}

// 初始化队列操作按钮
function initQueueActions() {
  const pauseAllBtn = document.getElementById('pauseAllBtn');
  const cancelAllBtn = document.getElementById('cancelAllBtn');
  
  if (pauseAllBtn) {
    pauseAllBtn.addEventListener('click', async () => {
      console.log('[Queue] 全部暂停');
      try {
        await ipcRenderer.invoke('pause-all-tasks');
        console.log('[Queue] ✅ 已暂停所有任务');
        await loadTransferTasks();
        // 刷新页面显示
        filterAndRenderTasks();
      } catch (error) {
        console.error('[Queue] ❌ 暂停失败:', error);
      }
    });
  }
  
  if (cancelAllBtn) {
    cancelAllBtn.addEventListener('click', async () => {
      console.log('[Queue] 全部取消');
      try {
        await ipcRenderer.invoke('cancel-all-tasks');
        console.log('[Queue] ✅ 已取消所有任务');
        await loadTransferTasks();
        // 刷新页面显示
        filterAndRenderTasks();
      } catch (error) {
        console.error('[Queue] ❌ 取消失败:', error);
      }
    });
  }
}

// 加载传输任务
async function loadTransferTasks() {
  try {
    console.log('[Queue] 从主进程获取传输任务...');
    // 从主进程获取所有传输任务
    allTasks = await ipcRenderer.invoke('get-tasks');
    console.log(`[Queue] 获取到 ${allTasks.length} 个任务`);
    
    // 初始过滤并渲染
    filterAndRenderTasks();
  } catch (error) {
    console.error('[Queue] 加载传输任务失败:', error);
    allTasks = [];
    showEmptyState();
  }
}

// 过滤并渲染任务（统一的过滤逻辑）
function filterAndRenderTasks() {
  console.log('[Queue] 过滤任务 - 类型:', currentFilter.type, '状态:', currentFilter.status);
  
  let filteredTasks = allTasks;
  
  // 1. 根据类型过滤（上传/下载）
  if (currentFilter.type === 'upload') {
    filteredTasks = filteredTasks.filter(task => task.type === 'upload');
    console.log(`[Queue] 上传任务: ${filteredTasks.length} 个`);
  } else if (currentFilter.type === 'download') {
    filteredTasks = filteredTasks.filter(task => task.type === 'download');
    console.log(`[Queue] 下载任务: ${filteredTasks.length} 个`);
  }
  
  // 2. 根据状态过滤（上传中/已完成）
  if (currentFilter.status === 'uploading') {
    // 上传中 = 非completed状态（包括active, pending, paused, failed等）
    filteredTasks = filteredTasks.filter(task => task.status !== 'completed');
    console.log(`[Queue] 进行中的任务: ${filteredTasks.length} 个`);
  } else if (currentFilter.status === 'completed') {
    // 已完成
    filteredTasks = filteredTasks.filter(task => task.status === 'completed');
    console.log(`[Queue] 已完成的任务: ${filteredTasks.length} 个`);
  }
  
  // 3. 渲染结果
  if (filteredTasks.length === 0) {
    showEmptyState();
    console.log('[Queue] 无任务，显示空状态');
  } else {
    hideEmptyState();
    renderTasks(filteredTasks);
    console.log(`[Queue] 渲染 ${filteredTasks.length} 个任务`);
  }
  
  // 4. 更新计数
  updateTabCounts();
}

// 设置任务监听器
function setupTaskListeners() {
  // 监听任务添加
  ipcRenderer.on('task-added', (event, task) => {
    console.log('[Queue] 新任务添加:', task.fileName);
    allTasks.unshift(task);
    filterAndRenderTasks();
  });
  
  // 监听任务进度更新
  ipcRenderer.on('task-progress', (event, task) => {
    const index = allTasks.findIndex(t => t.id === task.id);
    if (index !== -1) {
      allTasks[index] = task;
      filterAndRenderTasks();
    }
  });
  
  // 监听任务完成
  ipcRenderer.on('task-completed', (event, task) => {
    console.log('[Queue] 任务完成:', task.fileName);
    const index = allTasks.findIndex(t => t.id === task.id);
    if (index !== -1) {
      allTasks[index] = task;
      filterAndRenderTasks();
    }
  });
  
  // 监听任务失败
  ipcRenderer.on('task-failed', (event, task) => {
    console.log('[Queue] 任务失败:', task.fileName);
    const index = allTasks.findIndex(t => t.id === task.id);
    if (index !== -1) {
      allTasks[index] = task;
      filterAndRenderTasks();
    }
  });
}

// 渲染任务列表
function renderTasks(tasks) {
  const transferList = document.getElementById('transferList');
  
  if (!transferList) return;
  
  transferList.innerHTML = tasks.map(task => {
    const taskName = task.fileName || task.name || '未知文件';
    const taskProgress = task.progress || 0;
    const taskType = task.type || 'upload';
    
    return `
      <div class="transfer-item" data-id="${task.id}">
        <div class="transfer-icon">
          ${taskType === 'upload' ? '📤' : '📥'}
        </div>
        <div class="transfer-info">
          <div class="transfer-name">${taskName}</div>
          <div class="transfer-progress">
            <div class="transfer-progress-bar">
              <div class="transfer-progress-fill" style="width: ${taskProgress}%"></div>
            </div>
            <span class="transfer-status-text">${formatStatus(task)}</span>
          </div>
        </div>
        <div class="transfer-actions">
          ${getActionButtons(task)}
        </div>
      </div>
    `;
  }).join('');
}

// 根据任务状态获取操作按钮（蓝色文字样式）
function getActionButtons(task) {
  if (task.status === 'completed') {
    return '';
  } else if (task.status === 'paused') {
    return '<span class="transfer-action" onclick="resumeTask(\'' + task.id + '\')">继续</span>' +
           '<span class="transfer-action" onclick="cancelTask(\'' + task.id + '\')">取消</span>';
  } else if (task.status === 'failed') {
    return '<span class="transfer-action" onclick="retryTask(\'' + task.id + '\')">重试</span>' +
           '<span class="transfer-action" onclick="cancelTask(\'' + task.id + '\')">取消</span>';
  } else if (task.status === 'pending') {
    return '<span class="transfer-action" onclick="cancelTask(\'' + task.id + '\')">取消</span>';
  } else {
    // active状态
    return '<span class="transfer-action" onclick="pauseTask(\'' + task.id + '\')">暂停</span>' +
           '<span class="transfer-action" onclick="cancelTask(\'' + task.id + '\')">取消</span>';
  }
}

// 格式化状态文本
function formatStatus(task) {
  if (task.status === 'completed') {
    return '已完成';
  } else if (task.status === 'paused') {
    return '已暂停';
  } else if (task.status === 'failed') {
    return '失败';
  } else {
    return `${task.progress}%`;
  }
}

// 显示空状态
function showEmptyState() {
  const emptyState = document.getElementById('emptyState');
  const transferList = document.getElementById('transferList');
  
  if (emptyState) emptyState.style.display = 'flex';
  if (transferList) transferList.style.display = 'none';
}

// 隐藏空状态
function hideEmptyState() {
  const emptyState = document.getElementById('emptyState');
  const transferList = document.getElementById('transferList');
  
  if (emptyState) emptyState.style.display = 'none';
  if (transferList) transferList.style.display = 'flex';
}

// 更新标签计数
function updateTabCounts() {
  // 根据当前选中的类型（上传/下载）过滤任务
  let tasks = allTasks;
  if (currentFilter.type === 'upload') {
    tasks = tasks.filter(task => task.type === 'upload');
  } else if (currentFilter.type === 'download') {
    tasks = tasks.filter(task => task.type === 'download');
  }
  
  const uploadingCount = tasks.filter(task => task.status !== 'completed').length;
  const completedCount = tasks.filter(task => task.status === 'completed').length;
  
  const tabs = document.querySelectorAll('.queue-tab');
  tabs.forEach(tab => {
    const type = tab.dataset.tab;
    const span = tab.querySelector('span');
    
    if (type === 'uploading') {
      // 根据当前类型显示不同的文字
      const label = currentFilter.type === 'upload' ? '上传中' : '下载中';
      span.textContent = `${label}(${uploadingCount})`;
    } else if (type === 'completed') {
      span.textContent = `已完成(${completedCount})`;
    }
  });
}

// 暂停任务
async function pauseTask(taskId) {
  try {
    console.log('[Queue] 暂停任务:', taskId);
    await ipcRenderer.invoke('pause-task', taskId);
  } catch (error) {
    console.error('[Queue] 暂停任务失败:', error);
  }
}

// 继续任务
async function resumeTask(taskId) {
  try {
    console.log('[Queue] 继续任务:', taskId);
    await ipcRenderer.invoke('resume-task', taskId);
  } catch (error) {
    console.error('[Queue] 继续任务失败:', error);
  }
}

// 取消任务
async function cancelTask(taskId) {
  try {
    console.log('[Queue] 取消任务:', taskId);
    await ipcRenderer.invoke('cancel-task', taskId);
  } catch (error) {
    console.error('[Queue] 取消任务失败:', error);
  }
}

// 重试任务
async function retryTask(taskId) {
  try {
    console.log('[Queue] 重试任务:', taskId);
    await ipcRenderer.invoke('retry-task', taskId);
  } catch (error) {
    console.error('[Queue] 重试任务失败:', error);
  }
}

// 移除任务
async function removeTask(taskId) {
  try {
    console.log('[Queue] 移除任务:', taskId);
    // 从本地列表移除
    allTasks = allTasks.filter(t => t.id !== taskId);
    filterAndRenderTasks();
  } catch (error) {
    console.error('[Queue] 移除任务失败:', error);
  }
}
